/**
 *
 *  Copyright (c) 2011, AstroDAbis
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without modification,
 *  are permitted provided that the following conditions are met:
 *
 *      * Redistributions of source code must retain the above copyright notice,
 *        this list of conditions and the following disclaimer.
 *      * Redistributions in binary form must reproduce the above copyright notice,
 *        this list of conditions and the following disclaimer in the documentation
 *        and/or other materials provided with the distribution.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 *  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 *  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 *  OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 *  OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
package org.jiscinvolve.astrodabis.mallow.control.upload;

import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.io.IOException;

import java.util.Iterator;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.context.request.WebRequest;

import org.jiscinvolve.astrodabis.mallow.model.api.Account;

import org.jiscinvolve.astrodabis.mallow.control.ViewData;

import org.springframework.web.multipart.commons.CommonsMultipartFile;

/**
 * Upload data processor.
 *
 */
public class UploadData
extends ViewData
    {

    /**
     * Our debug logger.
     * 
     */
    private static Log log = LogFactory.getLog(UploadData.class);

    /**
     * Public constructor.
     *
     */
    public UploadData(WebRequest request)
        {
        super(request);
        }

    /**
     * Public constructor.
     *
     */
    public UploadData(WebRequest request, Account actor)
        {
        super(request, actor);
        }

    /**
     * The uploaded file data.
     *
     */
    private UploadBean bean ;

    /**
     * Set the uploaded file data.
     *
     */
    public void bean(UploadBean bean)
        {
        this.bean = bean ;
        }

    /**
     * Get the uploaded file data.
     *
     */
    public UploadBean bean()
        {
        return this.bean ;
        }

    /**
     * Get an iterator for the data processing.
     *
     */
    public Iterator<String> iter()
        {
        if (null == processor)
            {
            processor = new Processor();
            }
        return processor ;
        }

    /**
     * Our line processor.
     *
     */
    private Processor processor ;
    
    /**
     * Inner class to process the file.
     *
     */
    protected class Processor
    implements Iterator<String>
        {

        /**
         * Protected constructor.
         *
         */
        protected Processor()
            {
            try {
                //
                // Get the InputStream.
                reader = new LineNumberReader(
                    new InputStreamReader(
                        bean.getData().getInputStream()
                        )
                    );
                //
                // Read the first line.
                next = reader.readLine();
                }
            catch (IOException ouch)
                {
                log.error("IOException while processing file [" + ouch.getMessage() + "]");
                }
            }

        /**
         * Our line reader.
         *
         */
        private LineNumberReader reader ;

        /**
         * The current line.
         *
         */
        private String line ;

        /**
         * The next line.
         *
         */
        private String next ;
        
        /**
         * Check of we have another line.
         *
         */
        public boolean hasNext()
            {
            return (next != null) ;
            }
            
        /**
         * Get the next line.
         *
         */
        public String next()
            {
            if (null != reader)
                {
                try {
                    line = next ;
                    next = reader.readLine();
                    return line ;
                    }
                catch (IOException ouch)
                    {
                    log.error("IOException while processing file [" + ouch.getMessage() + "]");
                    next = null ;
                    return null ;
                    }
                }
            else {
                next = null ;
                return null ;
                }
            }
        
        public void remove()
            {
            }
        }

    /**
     * Process the uploaded file.
     *
    public void process()
        {

        log.debug("Processing upload data ...");

        try {

            log.debug("Name [" + bean.getName() + "]");
            log.debug("Name [" + bean.getData().getOriginalFilename() + "]");
            log.debug("Size [" + bean.getData().getSize() + "]");

            InputStream stream = bean.getData().getInputStream();
            if (null != stream)
                {
                log.debug("Got stream");
                LineNumberReader reader = new LineNumberReader(
                    new InputStreamReader(
                        stream
                        )
                    );

                log.debug("Reading data");
                String string = reader.readLine();
                while (string != null)
                    {
                    int count = reader.getLineNumber();
                    log.debug("Line [" + count + "][" + string + "]");
                    string = reader.readLine();
                    }
                log.debug("Done reading");

                }
            else {
                log.error("NULL stream");
                }
            }

        catch (IOException ouch)
            {
            log.error("IOException while processing file [" + ouch.getMessage() + "]");
            }
        }
     */
    }

